Python Redis-integratie: Caching en Message Queuing

Redis is een in-memory datastructuuropslag, vaak gebruikt als database, cache en message broker. De snelheid en veelzijdigheid maken het een populaire keuze voor Python-ontwikkelaars die de prestaties en schaalbaarheid van applicaties willen verbeteren. Deze uitgebreide gids onderzoekt hoe Redis met Python kan worden geïntegreerd voor zowel caching als message queuing, met praktische voorbeelden en best practices voor een wereldwijd publiek.

Waarom Redis gebruiken met Python?

Redis biedt verschillende voordelen bij integratie met Python-applicaties:

• Snelheid: Redis slaat gegevens in het geheugen op, wat extreem snelle lees- en schrijfbewerkingen mogelijk maakt. Dit is cruciaal voor caching en real-time gegevensverwerking.
• Gegevensstructuren: Naast eenvoudige key-value-paren ondersteunt Redis complexe gegevensstructuren zoals lijsten, sets, gesorteerde sets en hashes, waardoor het geschikt is voor verschillende use cases.
• Pub/Sub: Redis biedt een publish/subscribe-mechanisme voor real-time communicatie tussen verschillende onderdelen van een applicatie of zelfs tussen verschillende applicaties.
• Persistentie: Hoewel voornamelijk een in-memory opslag, biedt Redis persistentieopties om gegevensduurzaamheid te garanderen in geval van serverfouten.
• Schaalbaarheid: Redis kan horizontaal worden geschaald met behulp van technieken zoals sharding om grote hoeveelheden gegevens en verkeer te verwerken.

Redis en Python-omgeving instellen

Redis installeren

Het installatieproces varieert afhankelijk van uw besturingssysteem. Hier zijn instructies voor enkele populaire platforms:

• Linux (Debian/Ubuntu): sudo apt update && sudo apt install redis-server
• macOS (met behulp van Homebrew): brew install redis
• Windows (met behulp van WSL of Docker): Raadpleeg de officiële Redis-documentatie voor Windows-specifieke instructies. Docker is een veelgebruikte en aanbevolen aanpak.

Start na de installatie de Redis-server. Op de meeste systemen kunt u de opdracht redis-server gebruiken.

De Redis Python-client installeren

De populairste Python-client voor Redis is redis-py. Installeer deze met behulp van pip:

pip install redis

Caching met Redis

Caching is een fundamentele techniek om de prestaties van applicaties te verbeteren. Door veelgebruikte gegevens in Redis op te slaan, kunt u de belasting van uw database verminderen en de responstijden aanzienlijk versnellen.

Basis caching-voorbeeld

Hier is een eenvoudig voorbeeld van het cachen van gegevens die uit een database zijn gehaald met behulp van Redis:

            
import redis
import time

# Verbind met Redis
r = redis.Redis(host='localhost', port=6379, db=0)

# Simuleer een database query
def get_data_from_database(key):
 print(f"Gegevens ophalen uit database voor sleutel: {key}")
 time.sleep(1) # Simuleer een langzame database query
 return f"Gegevens voor {key} uit de database"

# Functie om gegevens op te halen uit cache of database
def get_data(key):
 cached_data = r.get(key)
 if cached_data:
 print(f"Gegevens ophalen uit cache voor sleutel: {key}")
 return cached_data.decode('utf-8')
 else:
 data = get_data_from_database(key)
 r.set(key, data, ex=60) # Cache voor 60 seconden
 return data

# Voorbeeldgebruik
print(get_data('user:123'))
print(get_data('user:123')) # Haalt op uit cache

            

              
                Copy
              
            
          

In dit voorbeeld:

• We maken verbinding met een Redis-instantie die draait op localhost poort 6379.
• De functie get_data controleert eerst of de gegevens al in de Redis-cache staan met behulp van r.get(key).
• Als de gegevens in de cache staan, worden ze direct geretourneerd.
• Als de gegevens niet in de cache staan, worden ze uit de database gehaald met behulp van get_data_from_database, opgeslagen in Redis met een vervaltijd (ex=60 seconden) en vervolgens geretourneerd.

Geavanceerde caching-technieken

• Cache invalidatie: Zorg ervoor dat uw cachegegevens up-to-date zijn door de cache te ongeldig te maken wanneer de onderliggende gegevens veranderen. Dit kan worden gedaan door de gecachede sleutel te verwijderen met behulp van r.delete(key).
• Cache-Aside-patroon: Het bovenstaande voorbeeld demonstreert het cache-aside-patroon, waarbij de applicatie verantwoordelijk is voor zowel het lezen uit de cache als het bijwerken ervan wanneer dat nodig is.
• Write-Through/Write-Back caching: Dit zijn complexere caching-strategieën waarbij gegevens tegelijkertijd naar de cache en de database worden geschreven (write-through) of eerst naar de cache en vervolgens asynchroon naar de database (write-back).
• Time-to-Live (TTL) gebruiken: Het instellen van een geschikte TTL voor uw gecachede gegevens is cruciaal om verouderde gegevens te voorkomen. Experimenteer om de optimale TTL voor de behoeften van uw applicatie te vinden.

Praktische caching-scenario's

• API-responscaching: Cache de reacties van API-eindpunten om de belasting van uw backend-servers te verminderen.
• Databasequery-caching: Cache de resultaten van veelgebruikte databasequery's om de responstijden te verbeteren.
• HTML-fragmentcaching: Cache fragmenten van HTML-pagina's om de hoeveelheid server-side rendering die nodig is te verminderen.
• User session caching: Sla gebruikerssessiegegevens op in Redis voor snelle toegang en schaalbaarheid.

Message Queuing met Redis

Redis kan worden gebruikt als message broker om asynchrone taakverwerking en ontkoppeling tussen verschillende componenten van uw applicatie te implementeren. Dit is met name handig voor het afhandelen van langlopende taken, zoals beeldverwerking, het verzenden van e-mails of het genereren van rapporten, zonder de belangrijkste applicatiethread te blokkeren.

Redis Pub/Sub

Het ingebouwde publish/subscribe (pub/sub)-mechanisme van Redis maakt het mogelijk om berichten naar meerdere abonnees te verzenden. Dit is een eenvoudige manier om basis message queuing te implementeren.

            
import redis
import time
import threading

# Verbind met Redis
r = redis.Redis(host='localhost', port=6379, db=0)

# Abonnee
def subscriber():
 pubsub = r.pubsub()
 pubsub.subscribe('my_channel')
 for message in pubsub.listen():
 if message['type'] == 'message':
 print(f"Ontvangen bericht: {message['data'].decode('utf-8')}")

# Uitgever
def publisher():
 time.sleep(1) # Wacht tot de abonnee verbinding maakt
 for i in range(5):
 message = f"Bericht {i}"
 r.publish('my_channel', message)
 print(f"Gepubliceerd bericht: {message}")
 time.sleep(1)

# Start abonnee in een aparte thread
subscriber_thread = threading.Thread(target=subscriber)
subscriber_thread.start()

# Start uitgever in de main thread
publisher()

subscriber_thread.join()

            

              
                Copy
              
            
          

In dit voorbeeld:

• De functie subscriber abonneert zich op het kanaal my_channel met behulp van pubsub.subscribe('my_channel').
• Vervolgens luistert het naar berichten met behulp van pubsub.listen() en drukt alle ontvangen berichten af.
• De functie publisher publiceert berichten naar het kanaal my_channel met behulp van r.publish('my_channel', message).
• De abonnee draait in een aparte thread om te voorkomen dat de uitgever wordt geblokkeerd.

Celery gebruiken

Celery is een populaire gedistribueerde taakwachtrij die Redis als message broker kan gebruiken. Het biedt een robuustere en functierijkere oplossing voor message queuing in vergelijking met de ingebouwde pub/sub van Redis.

Celery installeren

pip install celery redis

Celery-configuratie

Maak een bestand celeryconfig.py met de volgende inhoud:

            
broker_url = 'redis://localhost:6379/0'
result_backend = 'redis://localhost:6379/0'

            

              
                Copy
              
            
          

Taken definiëren

Maak een bestand tasks.py met de volgende inhoud:

            
from celery import Celery
import time

app = Celery('tasks', broker='redis://localhost:6379/0', backend='redis://localhost:6379/0')

@app.task
def add(x, y):
 time.sleep(5) # Simuleer een langlopende taak
 return x + y

            

              
                Copy
              
            
          

Celery Worker uitvoeren

Open een terminal en voer de volgende opdracht uit:

celery -A tasks worker --loglevel=info

Taken aanroepen

            
from tasks import add

result = add.delay(4, 4)
print(f"Taak-ID: {result.id}")

# Later kun je het resultaat controleren
# print(result.get()) # Dit blokkeert totdat de taak is voltooid

            

              
                Copy
              
            
          

In dit voorbeeld:

• We definiëren een Celery-taak met de naam add die twee argumenten gebruikt en hun som retourneert.
• De functie add.delay(4, 4) stuurt de taak naar de Celery-worker voor asynchrone uitvoering.
• Het object result vertegenwoordigt het asynchrone taakresultaat. U kunt result.get() gebruiken om het resultaat op te halen zodra de taak is voltooid. Houd er rekening mee dat result.get() blokkeert en wacht tot de taak is voltooid.

RQ (Redis Queue) gebruiken

RQ (Redis Queue) is een andere populaire bibliotheek voor het implementeren van taakwachtrijen met Redis. Het is eenvoudiger dan Celery, maar biedt nog steeds een robuuste oplossing voor asynchrone taakverwerking.

RQ installeren

pip install rq redis

Taken definiëren

Maak een bestand worker.py met de volgende inhoud:

            
import redis
from rq import Worker, Queue, Connection
import os

listen = ['default']

redis_url = os.getenv('REDIS_URL', 'redis://localhost:6379')

conn = redis.from_url(redis_url)

if __name__ == '__main__':
 with Connection(conn):
 worker = Worker(list(map(Queue, listen)))
 worker.work()

            

              
                Copy
              
            
          

Maak een bestand tasks.py met de volgende inhoud:

            
import time

def count_words_at_url(url):
 import requests
 resp = requests.get(url)
 return len(resp.text.split())

            

              
                Copy
              
            
          

Taken in de wachtrij plaatsen

            
import redis
from rq import Queue
from tasks import count_words_at_url

redis_url = os.getenv('REDIS_URL', 'redis://localhost:6379')
conn = redis.from_url(redis_url)

q = Queue(connection=conn)
result = q.enqueue(count_words_at_url, 'http://nvie.com')

#Je kunt het taakresultaat later ophalen
# from rq import job
#job = Job.fetch(result.id, connection=conn)
#print(job.result)

            

              
                Copy
              
            
          

RQ Worker uitvoeren

Open een terminal en voer de volgende opdracht uit:

python worker.py

In dit voorbeeld:

• We definiëren een functie count_words_at_url die de woorden op een bepaalde URL telt.
• We plaatsen de taak in de wachtrij met behulp van q.enqueue(count_words_at_url, 'http://nvie.com'), waarmee de taak aan de Redis-wachtrij wordt toegevoegd.
• De RQ-worker pikt de taak op en voert deze asynchroon uit.

De juiste message queue kiezen

De keuze tussen Redis pub/sub, Celery en RQ hangt af van de vereisten van uw applicatie:

• Redis Pub/Sub: Geschikt voor eenvoudige, real-time messaging-scenario's waar berichtaflevering niet kritiek is.
• Celery: Een goede keuze voor complexere taakwachtrijen met functies zoals taakplanning, nieuwe pogingen en het volgen van resultaten. Celery is een meer volwassen en functierijke oplossing.
• RQ: Een eenvoudiger alternatief voor Celery, geschikt voor basisbehoeften op het gebied van taakwachtrijen. Gemakkelijker in te stellen en te configureren.

Redis-gegevensstructuren voor geavanceerde use cases

Redis biedt een verscheidenheid aan gegevensstructuren die kunnen worden gebruikt om complexe problemen efficiënt op te lossen.

Lijsten

Redis-lijsten zijn geordende verzamelingen van strings. Ze kunnen worden gebruikt om wachtrijen, stacks en andere gegevensstructuren te implementeren.

            
import redis

r = redis.Redis(host='localhost', port=6379, db=0)

r.lpush('my_list', 'item1')
r.lpush('my_list', 'item2')
r.rpush('my_list', 'item3')

print(r.lrange('my_list', 0, -1)) # Uitvoer: [b'item2', b'item1', b'item3']

            

              
                Copy
              
            
          

Sets

Redis-sets zijn ongeordende verzamelingen van unieke strings. Ze kunnen worden gebruikt om lidmaatschapstests, union-, intersection- en verschilbewerkingen te implementeren.

            
import redis

r = redis.Redis(host='localhost', port=6379, db=0)

r.sadd('my_set', 'item1')
r.sadd('my_set', 'item2')
r.sadd('my_set', 'item1') # Het opnieuw toevoegen van hetzelfde item heeft geen effect

print(r.smembers('my_set')) # Uitvoer: {b'item2', b'item1'}

            

              
                Copy
              
            
          

Gesorteerde Sets

Redis gesorteerde sets lijken op sets, maar elk element is gekoppeld aan een score. De elementen worden gesorteerd op basis van hun scores. Ze kunnen worden gebruikt om ranglijsten, prioriteitswachtrijen en bereikquery's te implementeren.

            
import redis

r = redis.Redis(host='localhost', port=6379, db=0)

r.zadd('my_sorted_set', {'item1': 10, 'item2': 5, 'item3': 15})

print(r.zrange('my_sorted_set', 0, -1)) # Uitvoer: [b'item2', b'item1', b'item3']

            

              
                Copy
              
            
          

Hashes

Redis hashes zijn key-value stores waarbij zowel de key als de value strings zijn. Ze kunnen worden gebruikt om objecten op te slaan en atomaire bewerkingen uit te voeren op afzonderlijke velden.

            
import redis

r = redis.Redis(host='localhost', port=6379, db=0)

r.hset('my_hash', 'field1', 'value1')
r.hset('my_hash', 'field2', 'value2')

print(r.hgetall('my_hash')) # Uitvoer: {b'field1': b'value1', b'field2': b'value2'}

            

              
                Copy
              
            
          

Best practices voor Python Redis-integratie

• Verbindingspooling: Gebruik connection pooling om te voorkomen dat voor elke bewerking een nieuwe verbinding met Redis wordt gemaakt. De redis-py client biedt ingebouwde connection pooling.
• Foutafhandeling: Implementeer de juiste foutafhandeling om uitzonderingen op te vangen en verbindingsfouten op een nette manier af te handelen.
• Gegevensserialisatie: Kies een geschikte gegevensserialisatie-indeling, zoals JSON of pickle, om complexe objecten in Redis op te slaan. Houd rekening met de prestatie- en beveiligingsimplicaties van elke indeling.
• Key-namingconventies: Gebruik consistente en beschrijvende key-namingconventies om uw gegevens in Redis te organiseren. Bijvoorbeeld user:{user_id}:name.
• Monitoring en logging: Bewaak de prestaties van uw Redis-server en log eventuele fouten of waarschuwingen. Gebruik tools zoals RedisInsight om het resourcegebruik te bewaken en potentiële knelpunten te identificeren.
• Beveiliging: Beveilig uw Redis-server door een sterk wachtwoord in te stellen, onnodige opdrachten uit te schakelen en toegangsbeperkingen voor het netwerk te configureren. Voer Redis indien mogelijk uit in een beveiligde netwerkomgeving.
• Kies de juiste Redis-instantie: Overweeg de werklast van uw applicatie en kies de juiste grootte voor uw Redis-instantie. Overbelasting van een Redis-instantie kan leiden tot prestatievermindering en instabiliteit.

Algemene overwegingen

• Tijdzones: Houd bij het cachen van gegevens die tijdstempels bevatten rekening met tijdzones en sla tijdstempels op in een consistente indeling (bijvoorbeeld UTC).
• Valuta's: Wanneer u financiële gegevens cached, moet u valutaconversies zorgvuldig afhandelen.
• Tekencodering: Gebruik UTF-8-codering voor alle strings die in Redis zijn opgeslagen om een breed scala aan talen te ondersteunen.
• Lokalisatie: Als uw applicatie is gelokaliseerd, cache dan verschillende versies van de gegevens voor elke landinstelling.

Conclusie

Het integreren van Redis met Python kan de prestaties en schaalbaarheid van uw applicaties aanzienlijk verbeteren. Door Redis te gebruiken voor caching en message queuing, kunt u de belasting van uw database verminderen, langlopende taken asynchroon afhandelen en responsievere en robuustere systemen bouwen. Deze gids heeft een uitgebreid overzicht gegeven van hoe u Redis met Python kunt gebruiken, met basisconcepten, geavanceerde technieken en best practices voor een wereldwijd publiek. Vergeet niet om rekening te houden met de specifieke applicatievereisten en kies de juiste tools en strategieën om de voordelen van Redis-integratie te maximaliseren.